home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / java / text / DecimalFormat.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  8.4 KB  |  629 lines
  1. package java.text;
  2.  
  3. import java.util.Locale;
  4. import java.util.ResourceBundle;
  5.  
  6. public class DecimalFormat extends NumberFormat {
  7.    private transient DigitList digitList = new DigitList();
  8.    private String positivePrefix = "";
  9.    private String positiveSuffix = "";
  10.    private String negativePrefix = "-";
  11.    private String negativeSuffix = "";
  12.    private int multiplier = 1;
  13.    private byte groupingSize = 3;
  14.    private boolean decimalSeparatorAlwaysShown = false;
  15.    private DecimalFormatSymbols symbols = new DecimalFormatSymbols();
  16.    private static final char patternZeroDigit = '0';
  17.    private static final char patternGroupingSeparator = ',';
  18.    private static final char patternDecimalSeparator = '.';
  19.    private static final char patternPerMill = 'ΓÇ░';
  20.    private static final char patternPercent = '%';
  21.    private static final char patternDigit = '#';
  22.    private static final char patternSeparator = ';';
  23.  
  24.    public DecimalFormat() {
  25.       ResourceBundle var1 = ResourceBundle.getBundle("java.text.resources.LocaleElements", Locale.getDefault());
  26.       String[] var2 = var1.getStringArray("NumberPatterns");
  27.       this.applyPattern(var2[0], false);
  28.       this.symbols = new DecimalFormatSymbols(Locale.getDefault());
  29.    }
  30.  
  31.    public DecimalFormat(String var1) {
  32.       this.applyPattern(var1, false);
  33.       this.symbols = new DecimalFormatSymbols(Locale.getDefault());
  34.    }
  35.  
  36.    public DecimalFormat(String var1, DecimalFormatSymbols var2) {
  37.       this.applyPattern(var1, false);
  38.       this.symbols = var2;
  39.    }
  40.  
  41.    public StringBuffer format(double var1, StringBuffer var3, FieldPosition var4) {
  42.       var4.beginIndex = var4.endIndex = 0;
  43.       if (Double.isNaN(var1)) {
  44.          var3.append(this.symbols.getNaN());
  45.       } else {
  46.          boolean var5 = var1 < (double)0.0F;
  47.          if (!var5) {
  48.             var3.append(this.positivePrefix);
  49.          } else {
  50.             var3.append(this.negativePrefix);
  51.             var1 = -var1;
  52.          }
  53.  
  54.          if (Double.isInfinite(var1)) {
  55.             var3.append(this.symbols.getInfinity());
  56.          } else {
  57.             if (this.multiplier != 1) {
  58.                var1 *= (double)this.multiplier;
  59.             }
  60.  
  61.             this.digitList.set(var1, ((NumberFormat)this).getMaximumFractionDigits());
  62.             this.appendNativeDigits(var3, var4);
  63.          }
  64.  
  65.          if (!var5) {
  66.             var3.append(this.positiveSuffix);
  67.          } else {
  68.             var3.append(this.negativeSuffix);
  69.          }
  70.       }
  71.  
  72.       return var3;
  73.    }
  74.  
  75.    public StringBuffer format(long var1, StringBuffer var3, FieldPosition var4) {
  76.       var4.beginIndex = var4.endIndex = 0;
  77.       if (Double.isNaN((double)var1)) {
  78.          var3.append(this.symbols.getNaN());
  79.       } else {
  80.          boolean var5 = var1 < 0L;
  81.          if (!var5) {
  82.             var3.append(this.positivePrefix);
  83.          } else {
  84.             var3.append(this.negativePrefix);
  85.             var1 = -var1;
  86.          }
  87.  
  88.          if (Double.isInfinite((double)var1)) {
  89.             var3.append(this.symbols.getInfinity());
  90.          } else {
  91.             if (this.multiplier != 1) {
  92.                var1 *= (long)this.multiplier;
  93.             }
  94.  
  95.             this.digitList.set(var1);
  96.             this.appendNativeDigits(var3, var4);
  97.          }
  98.  
  99.          if (!var5) {
  100.             var3.append(this.positiveSuffix);
  101.          } else {
  102.             var3.append(this.negativeSuffix);
  103.          }
  104.       }
  105.  
  106.       return var3;
  107.    }
  108.  
  109.    public Number parse(String var1, ParsePosition var2) {
  110.       int var3 = var2.index;
  111.       if (var1.regionMatches(var3, this.symbols.getNaN(), 0, this.symbols.getNaN().length())) {
  112.          var2.index = var3 + this.symbols.getNaN().length();
  113.          return new Double(Double.NaN);
  114.       } else {
  115.          boolean var4 = var1.regionMatches(var3, this.positivePrefix, 0, this.positivePrefix.length());
  116.          boolean var5 = var1.regionMatches(var3, this.negativePrefix, 0, this.negativePrefix.length());
  117.          if (var4 && var5) {
  118.             if (this.positivePrefix.length() > this.negativePrefix.length()) {
  119.                var5 = false;
  120.             } else if (this.positivePrefix.length() < this.negativePrefix.length()) {
  121.                var4 = false;
  122.             }
  123.          }
  124.  
  125.          if (var4) {
  126.             var3 += this.positivePrefix.length();
  127.          } else {
  128.             if (!var5) {
  129.                return null;
  130.             }
  131.  
  132.             var3 += this.negativePrefix.length();
  133.          }
  134.  
  135.          double var6 = Double.NaN;
  136.          long var8 = Long.MIN_VALUE;
  137.          boolean var10 = true;
  138.          if (var1.regionMatches(var3, this.symbols.getInfinity(), 0, this.symbols.getInfinity().length())) {
  139.             var3 += this.symbols.getInfinity().length();
  140.             this.digitList.decimalAt = var3;
  141.             var6 = Double.POSITIVE_INFINITY;
  142.          } else {
  143.             this.digitList.count = 0;
  144.             this.digitList.decimalAt = -1;
  145.             int var11 = -1;
  146.             int var12 = -1;
  147.  
  148.             boolean var13;
  149.             for(var13 = false; var3 < var1.length(); ++var3) {
  150.                char var14 = var1.charAt(var3);
  151.                if (this.symbols.getZeroDigit() < var14 && var14 <= (char)(this.symbols.getZeroDigit() + 9)) {
  152.                   var11 = -1;
  153.                   this.digitList.decimalAt = var12;
  154.                   this.digitList.append(var14 - this.symbols.getZeroDigit() + 48);
  155.                } else if (var14 == this.symbols.getZeroDigit()) {
  156.                   var13 = true;
  157.                   if (this.digitList.count != 0 || var12 != -1) {
  158.                      var11 = -1;
  159.                      this.digitList.decimalAt = var12;
  160.                      if (this.digitList.count != 0 || var12 != -1) {
  161.                         this.digitList.append(var14 - this.symbols.getZeroDigit() + 48);
  162.                      }
  163.                   }
  164.                } else {
  165.                   if (this.digitList.decimalAt >= 0) {
  166.                      break;
  167.                   }
  168.  
  169.                   if (var14 == this.symbols.getDecimalSeparator() && !((NumberFormat)this).isParseIntegerOnly()) {
  170.                      var11 = var3;
  171.                      var12 = this.digitList.count;
  172.                   } else {
  173.                      if (var14 != this.symbols.getGroupingSeparator() || !((NumberFormat)this).isGroupingUsed()) {
  174.                         break;
  175.                      }
  176.  
  177.                      var11 = var3;
  178.                   }
  179.                }
  180.             }
  181.  
  182.             if (var11 != -1) {
  183.                var3 = var11;
  184.             }
  185.  
  186.             if (this.digitList.decimalAt == -1) {
  187.                this.digitList.decimalAt = this.digitList.count;
  188.             }
  189.  
  190.             if (this.digitList.decimalAt == this.digitList.count && this.digitList.count <= 19) {
  191.                var10 = false;
  192.                if (this.digitList.count == 19 && var5 && this.isLongMIN_VALUE(this.digitList)) {
  193.                   var8 = Long.MIN_VALUE;
  194.                } else if (this.digitList.count == 0) {
  195.                   if (!var13) {
  196.                      return null;
  197.                   }
  198.  
  199.                   var8 = 0L;
  200.                } else {
  201.                   var8 = this.digitList.getLong();
  202.                }
  203.             } else {
  204.                if (this.digitList.count == 0) {
  205.                   return null;
  206.                }
  207.  
  208.                var6 = this.digitList.getDouble();
  209.             }
  210.          }
  211.  
  212.          if (var4) {
  213.             var4 = var1.regionMatches(var3, this.positiveSuffix, 0, this.positiveSuffix.length());
  214.          }
  215.  
  216.          if (var5) {
  217.             var5 = var1.regionMatches(var3, this.negativeSuffix, 0, this.negativeSuffix.length());
  218.          }
  219.  
  220.          if (!var4 && !var5) {
  221.             return null;
  222.          } else {
  223.             if (var4 && var5) {
  224.                if (this.positiveSuffix.length() > this.negativeSuffix.length()) {
  225.                   var5 = false;
  226.                } else {
  227.                   if (this.positiveSuffix.length() >= this.negativeSuffix.length()) {
  228.                      return null;
  229.                   }
  230.  
  231.                   var4 = false;
  232.                }
  233.             }
  234.  
  235.             if (var4 == var5) {
  236.                return null;
  237.             } else {
  238.                if (this.multiplier != 1) {
  239.                   if (var10) {
  240.                      var6 /= (double)this.multiplier;
  241.                   } else {
  242.                      var6 = (double)var8 / (double)this.multiplier;
  243.                      var10 = true;
  244.                   }
  245.                }
  246.  
  247.                if (var4) {
  248.                   var2.index = var3 + this.positiveSuffix.length();
  249.                } else {
  250.                   var2.index = var3 + this.negativeSuffix.length();
  251.                   var6 = -var6;
  252.                   var8 = -var8;
  253.                }
  254.  
  255.                if (var10) {
  256.                   return new Double(var6);
  257.                } else {
  258.                   return (Number)(this.digitList.decimalAt != this.digitList.count || var8 < Long.MIN_VALUE && var8 > Long.MAX_VALUE ? new Double((double)var8) : new Long(var8));
  259.                }
  260.             }
  261.          }
  262.       }
  263.    }
  264.  
  265.    public DecimalFormatSymbols getDecimalFormatSymbols() {
  266.       try {
  267.          return (DecimalFormatSymbols)this.symbols.clone();
  268.       } catch (Exception var1) {
  269.          return null;
  270.       }
  271.    }
  272.  
  273.    public void setDecimalFormatSymbols(DecimalFormatSymbols var1) {
  274.       try {
  275.          this.symbols = (DecimalFormatSymbols)var1.clone();
  276.       } catch (Exception var2) {
  277.       }
  278.    }
  279.  
  280.    public String getPositivePrefix() {
  281.       return this.positivePrefix;
  282.    }
  283.  
  284.    public void setPositivePrefix(String var1) {
  285.       this.positivePrefix = var1;
  286.    }
  287.  
  288.    public String getNegativePrefix() {
  289.       return this.negativePrefix;
  290.    }
  291.  
  292.    public void setNegativePrefix(String var1) {
  293.       this.negativePrefix = var1;
  294.    }
  295.  
  296.    public String getPositiveSuffix() {
  297.       return this.positiveSuffix;
  298.    }
  299.  
  300.    public void setPositiveSuffix(String var1) {
  301.       this.positiveSuffix = var1;
  302.    }
  303.  
  304.    public String getNegativeSuffix() {
  305.       return this.negativeSuffix;
  306.    }
  307.  
  308.    public void setNegativeSuffix(String var1) {
  309.       this.negativeSuffix = var1;
  310.    }
  311.  
  312.    public int getMultiplier() {
  313.       return this.multiplier;
  314.    }
  315.  
  316.    public void setMultiplier(int var1) {
  317.       this.multiplier = var1;
  318.    }
  319.  
  320.    public int getGroupingSize() {
  321.       return this.groupingSize;
  322.    }
  323.  
  324.    public void setGroupingSize(int var1) {
  325.       this.groupingSize = (byte)var1;
  326.    }
  327.  
  328.    public boolean isDecimalSeparatorAlwaysShown() {
  329.       return this.decimalSeparatorAlwaysShown;
  330.    }
  331.  
  332.    public void setDecimalSeparatorAlwaysShown(boolean var1) {
  333.       this.decimalSeparatorAlwaysShown = var1;
  334.    }
  335.  
  336.    public Object clone() {
  337.       try {
  338.          DecimalFormat var1 = (DecimalFormat)super.clone();
  339.          var1.symbols = (DecimalFormatSymbols)this.symbols.clone();
  340.          return var1;
  341.       } catch (Exception var2) {
  342.          throw new InternalError();
  343.       }
  344.    }
  345.  
  346.    public boolean equals(Object var1) {
  347.       if (!super.equals(var1)) {
  348.          return false;
  349.       } else {
  350.          DecimalFormat var2 = (DecimalFormat)var1;
  351.          return this.positivePrefix.equals(var2.positivePrefix) && this.positiveSuffix.equals(var2.positiveSuffix) && this.negativePrefix.equals(var2.negativePrefix) && this.negativeSuffix.equals(var2.negativeSuffix) && this.multiplier == var2.multiplier && this.groupingSize == var2.groupingSize && this.decimalSeparatorAlwaysShown == var2.decimalSeparatorAlwaysShown && this.symbols.equals(var2.symbols);
  352.       }
  353.    }
  354.  
  355.    public int hashCode() {
  356.       return super.hashCode() * 37 + this.positivePrefix.hashCode();
  357.    }
  358.  
  359.    public String toPattern() {
  360.       return this.toPattern(false);
  361.    }
  362.  
  363.    public String toLocalizedPattern() {
  364.       return this.toPattern(true);
  365.    }
  366.  
  367.    private String toPattern(boolean var1) {
  368.       StringBuffer var2 = new StringBuffer();
  369.  
  370.       for(int var3 = 1; var3 >= 0; --var3) {
  371.          if (var3 == 1) {
  372.             var2.append(this.positivePrefix);
  373.          } else {
  374.             var2.append(this.negativePrefix);
  375.          }
  376.  
  377.          int var4 = Math.max(this.groupingSize, ((NumberFormat)this).getMinimumIntegerDigits()) + 1;
  378.  
  379.          for(int var5 = var4; var5 > 0; --var5) {
  380.             if (var5 == this.groupingSize) {
  381.                var2.append(var1 ? this.symbols.getGroupingSeparator() : ',');
  382.             }
  383.  
  384.             if (var5 <= ((NumberFormat)this).getMinimumIntegerDigits()) {
  385.                var2.append(var1 ? this.symbols.getZeroDigit() : '0');
  386.             } else {
  387.                var2.append(var1 ? this.symbols.getDigit() : '#');
  388.             }
  389.          }
  390.  
  391.          if (((NumberFormat)this).getMaximumFractionDigits() > 0) {
  392.             var2.append(var1 ? this.symbols.getDecimalSeparator() : '.');
  393.          }
  394.  
  395.          for(int var6 = 0; var6 < ((NumberFormat)this).getMaximumFractionDigits(); ++var6) {
  396.             if (var6 < ((NumberFormat)this).getMinimumFractionDigits()) {
  397.                var2.append(var1 ? this.symbols.getZeroDigit() : '0');
  398.             } else {
  399.                var2.append(var1 ? this.symbols.getDigit() : '#');
  400.             }
  401.          }
  402.  
  403.          if (var3 == 1) {
  404.             var2.append(this.positiveSuffix);
  405.             if (this.negativeSuffix.equals(this.positiveSuffix) && this.negativePrefix.equals(this.symbols.getMinusSign() + this.positivePrefix)) {
  406.                break;
  407.             }
  408.  
  409.             var2.append(var1 ? this.symbols.getPatternSeparator() : ';');
  410.          } else {
  411.             var2.append(this.negativeSuffix);
  412.          }
  413.       }
  414.  
  415.       return var2.toString();
  416.    }
  417.  
  418.    public void applyPattern(String var1) {
  419.       this.applyPattern(var1, false);
  420.    }
  421.  
  422.    public void applyLocalizedPattern(String var1) {
  423.       this.applyPattern(var1, true);
  424.    }
  425.  
  426.    private void applyPattern(String var1, boolean var2) {
  427.       int var3 = 0;
  428.       boolean var4 = false;
  429.       boolean var5 = false;
  430.  
  431.       for(int var6 = 1; var6 >= 0 && var3 < var1.length(); --var6) {
  432.          StringBuffer var7 = new StringBuffer();
  433.          StringBuffer var8 = new StringBuffer();
  434.          byte var9 = 0;
  435.          byte var10 = 0;
  436.          byte var11 = 0;
  437.          byte var12 = 0;
  438.          short var13 = 1;
  439.          boolean var14 = false;
  440.          boolean var15 = false;
  441.          byte var16 = 0;
  442.          char var17 = '0';
  443.          char var18 = ',';
  444.          char var19 = '.';
  445.          char var20 = '%';
  446.          char var21 = 8240;
  447.          char var22 = '#';
  448.          char var23 = ';';
  449.          if (var2) {
  450.             var17 = this.symbols.getZeroDigit();
  451.             var18 = this.symbols.getGroupingSeparator();
  452.             var19 = this.symbols.getDecimalSeparator();
  453.             var20 = this.symbols.getPercent();
  454.             var21 = this.symbols.getPerMill();
  455.             var22 = this.symbols.getDigit();
  456.             var23 = this.symbols.getPatternSeparator();
  457.          }
  458.  
  459.          for(; var3 < var1.length(); ++var3) {
  460.             char var24 = var1.charAt(var3);
  461.             if (var4) {
  462.                if (var24 == '\'') {
  463.                   var4 = false;
  464.                } else if (var9 <= 0) {
  465.                   var7.append(var24);
  466.                } else {
  467.                   var8.append(var24);
  468.                }
  469.             } else if (var24 == '\'') {
  470.                var4 = true;
  471.             } else {
  472.                if (var24 == var23) {
  473.                   ++var3;
  474.                   break;
  475.                }
  476.  
  477.                if (!var15) {
  478.                   if (var24 == var22) {
  479.                      ++var9;
  480.                      if (var10 > 0) {
  481.                         throw new IllegalArgumentException();
  482.                      }
  483.  
  484.                      if (var14) {
  485.                         ++var16;
  486.                      }
  487.                   } else if (var24 == var17) {
  488.                      ++var10;
  489.                      ++var9;
  490.                      if (var14) {
  491.                         ++var16;
  492.                      }
  493.                   } else if (var24 == var18) {
  494.                      var14 = true;
  495.                      var16 = 0;
  496.                   } else if (var24 == var19) {
  497.                      if (var15) {
  498.                         throw new IllegalArgumentException();
  499.                      }
  500.  
  501.                      var15 = true;
  502.                   } else if (var9 > 0) {
  503.                      if (var15) {
  504.                         throw new IllegalArgumentException();
  505.                      }
  506.  
  507.                      var15 = true;
  508.                      if (var24 == var20) {
  509.                         var8.append(this.symbols.getPercent());
  510.                         var13 = 100;
  511.                      } else if (var24 == var21) {
  512.                         var8.append(this.symbols.getPerMill());
  513.                         var13 = 1000;
  514.                      } else {
  515.                         var8.append(var24);
  516.                      }
  517.                   } else {
  518.                      var7.append(var24);
  519.                   }
  520.                } else if (var24 == var22) {
  521.                   ++var11;
  522.                } else if (var24 == var17) {
  523.                   ++var12;
  524.                   ++var11;
  525.                } else if (var24 == var20) {
  526.                   var8.append(this.symbols.getPercent());
  527.                   var13 = 100;
  528.                } else if (var24 == var21) {
  529.                   var8.append(this.symbols.getPerMill());
  530.                   var13 = 1000;
  531.                } else {
  532.                   var8.append(var24);
  533.                }
  534.             }
  535.          }
  536.  
  537.          if (var6 == 1) {
  538.             this.positivePrefix = var7.toString();
  539.             this.positiveSuffix = var8.toString();
  540.             this.negativePrefix = this.positivePrefix;
  541.             this.negativeSuffix = this.positiveSuffix;
  542.             ((NumberFormat)this).setMaximumIntegerDigits(127);
  543.             ((NumberFormat)this).setMinimumIntegerDigits(var10);
  544.             ((NumberFormat)this).setMaximumFractionDigits(var11);
  545.             ((NumberFormat)this).setMinimumFractionDigits(var12);
  546.             ((NumberFormat)this).setGroupingUsed(var14);
  547.             var15 = false;
  548.             this.setDecimalSeparatorAlwaysShown(var15);
  549.             this.groupingSize = var16;
  550.             this.multiplier = var13;
  551.          } else {
  552.             this.negativePrefix = var7.toString();
  553.             this.negativeSuffix = var8.toString();
  554.             var5 = true;
  555.          }
  556.       }
  557.  
  558.       if (!var5 || this.negativePrefix.equals(this.positivePrefix) && this.negativeSuffix.equals(this.positiveSuffix)) {
  559.          this.negativeSuffix = this.positiveSuffix;
  560.          this.negativePrefix = this.symbols.getMinusSign() + this.negativePrefix;
  561.       }
  562.  
  563.    }
  564.  
  565.    private void appendNativeDigits(StringBuffer var1, FieldPosition var2) {
  566.       int var3 = this.digitList.decimalAt;
  567.       if (var2.field == 0) {
  568.          var2.beginIndex = var1.length();
  569.       }
  570.  
  571.       int var4 = 0;
  572.       int var5 = Math.max(((NumberFormat)this).getMinimumIntegerDigits(), Math.min(var3 - var4, ((NumberFormat)this).getMaximumIntegerDigits()));
  573.  
  574.       for(int var6 = var5; var6 > 0; --var6) {
  575.          if (var6 <= var3 - var4 && var3 - var6 < this.digitList.count) {
  576.             var1.append((char)(this.digitList.digits[var3 - var6] - 48 + this.symbols.getZeroDigit()));
  577.          } else {
  578.             var1.append(this.symbols.getZeroDigit());
  579.          }
  580.  
  581.          if (((NumberFormat)this).isGroupingUsed() && (var6 - 1) % this.groupingSize == 0 && var6 != 1) {
  582.             var1.append(this.symbols.getGroupingSeparator());
  583.          }
  584.       }
  585.  
  586.       if (var2.field == 0) {
  587.          var2.endIndex = var1.length();
  588.       }
  589.  
  590.       var4 = var3;
  591.       int var8 = this.digitList.count;
  592.       var5 = Math.max(((NumberFormat)this).getMinimumFractionDigits(), Math.min(var8 - var3, ((NumberFormat)this).getMaximumFractionDigits()));
  593.       if (this.decimalSeparatorAlwaysShown || var5 > 0) {
  594.          var1.append(this.symbols.getDecimalSeparator());
  595.          if (var2.field == 1) {
  596.             var2.beginIndex = var1.length();
  597.          }
  598.  
  599.          for(int var7 = 0; var7 < var5; ++var7) {
  600.             if (var7 >= var8 - var4) {
  601.                var1.append(this.symbols.getZeroDigit());
  602.             } else {
  603.                var1.append((char)(this.digitList.digits[var4 + var7] - 48 + this.symbols.getZeroDigit()));
  604.             }
  605.          }
  606.  
  607.          if (var2.field == 1) {
  608.             var2.endIndex = var1.length();
  609.          }
  610.       }
  611.  
  612.    }
  613.  
  614.    private boolean isSpecialChar(char var1) {
  615.       return var1 == '0' || var1 == ',' || var1 == '.' || var1 == '%' || var1 == 8240 || var1 == '#' || var1 == ';';
  616.    }
  617.  
  618.    private boolean isLongMIN_VALUE(DigitList var1) {
  619.       StringBuffer var2 = new StringBuffer(var1.count + 1);
  620.       var2.append('-');
  621.  
  622.       for(int var3 = 0; var3 < var1.count; ++var3) {
  623.          var2.append((char)var1.digits[var3]);
  624.       }
  625.  
  626.       return var2.toString().regionMatches(false, 0, Long.toString(Long.MIN_VALUE), 0, var1.count + 1);
  627.    }
  628. }
  629.